(function (window) {
    // 将状态声明为常量。全局（应用）性质的常量一般要求大写。
    const PENDING = "pending";
    const FULFILLED = "fulfilled";
    const REJECTED = "rejected"
    // 定义了一个构造函数，该构造函数接收执行器函数(executor)
    function Promise(executor) {
        // 增加实例属性state，初始值为pending
        this.state = PENDING;
        // 增加实例属性result,初始值为undefined
        this.result = undefined;
        const _resolve = value => {
            // 如果状态发生变化，那么后续代码不会执行
            if (this.state !== PENDING) return;
            // 将当前的状态更改为fulfilled,值为接收的value
            this.state = FULFILLED;
            this.result = value;
        }
        const _reject = value => {
            // 如果状态发生变化，那么后续代码不会执行
            if (this.state !== PENDING) return;
            // 将当前的状态更改为rejected,值为接收的value
            this.state = REJECTED;
            this.result = value;
        }
        try {
            executor(_resolve, _reject);
        } catch (err) {
            // 如果状态发生变化，那么后续代码不会执行
            _reject(err)
        }
    }
    Object.assign(Promise.prototype,{
        // 1- 接收两个回调函数（onResolved成功回调，onRejected失败回调）
        // 2- 如果状态为成功，则调用onResolved函数
        // 3- 如果状态为失败，则调用onRejected函数
        then(onResolved,onRejected){
            // 返回一个新的promise,在执行器函数中直接判断状态调用对应的成功或失败回调
            // 根据成功或失败回调的返回结果，来修改返回promise的状态以及值。
            return new Promise((resolve,reject)=>{
                // 判断状态是否为成功
                if(this.state === FULFILLED){
                    // 异步调用成功回调
                    setTimeout(()=>{
                        // 将成功回调的返回值赋值给常量value
                        try{
                            const value = onResolved(this.result);// 调用成功回调，并将成功值传递过去
                            // 判断value是否为Promise实例
                            if(value instanceof Promise){
                                // 是Promise实例,将value的状态以及值，作为返回新的promise的状态以及值。
                                // value.then(_value=>{
                                //     // value状态为成功，值为_value
                                //     resolve(_value);
                                // },_reason=>{
                                //     // value状态为失败，值为_reason
                                //     reject(_reason);
                                // })

                                // 简化箭头函数:
                                // value.then(_value=>resolve(_value),_reason=>reject(_reason));

                                // 写成:
                                value.then(resolve,reject);
                                

                            }else{
                                // 不是Promise实例，将返回的新的Promise的状态更改为成功，值为value
                                resolve(value);
                            }
                        }catch(err){
                            // 有异常,，将返回的新的Promise的状态更改为失败，值为异常信息
                            reject(err);
                        }
                       

                    });               
                }else if(this.state === REJECTED){
                    // 异步调用失败回调
                    setTimeout(()=>{
                        // 判断状态是否为失败
                        try{
                            const value = onRejected(this.result);// 调用失败回调，并将失败值传递过去
                             // 判断value是否为Promise实例
                             if(value instanceof Promise){
                                // // 是Promise实例,将value的状态以及值，作为返回新的promise的状态以及值。
                                // value.then(_value=>{
                                //     // value状态为成功，值为_value
                                //     resolve(_value);
                                // },_reason=>{
                                //     // value状态为失败，值为_reason
                                //     reject(_reason);
                                // })
                                
                                // 写成:
                                value.then(resolve,reject);
                            }else{
                                // 不是Promise实例，将返回的新的Promise的状态更改为成功，值为value
                                resolve(value);
                            }
                        }catch(err){
                              // 有异常,，将返回的新的Promise的状态更改为失败，值为异常信息
                              reject(err);
                        }
                       
                    })
                    
                }
            })
            
        },
        catch(){

        }
    })
    window.Promise = Promise;
})(window);